import sys
import pandas as pd
from collections import Counter
import numpy as np
import requests
import json

max_consecutive = []


from collections import Counter

def count_error_3_right_combinations(boolean_list,count):
    # 创建一个 Counter 用于统计每种 (错误次数, 正确次数) 组合出现的次数
    combo_count = Counter()
    
    current_errors = 0  # 当前连续错误的次数
    current_rights = 0  # 当前连续正确的次数
    is_error_3 = False  # 标记是否已经遇到 3 次错误
    
    # 遍历布尔值列表
    for num in boolean_list:
        if num < 0 or num > count:
            if current_errors > 0 and current_rights > 0:
                combo_count[(current_errors, current_rights)] += 1
                current_errors = 0
                current_rights = 0
            # 当前是错误
            current_errors += 1
        else:
            # 当前是正确
            current_rights += 1
    # 返回统计结果
    return combo_count




# 我们可以编写一个函数来计算在给定的数字列表中，连续小于{count}的数字的最大次数。
def max_consecutive_less_than_count(numbers,count):
    max_count = 0  # 记录最大连续次数
    current_count = 0  # 记录当前连续次数

    for index,num in enumerate(numbers):
        if num < 0 or num > count:
            current_count += 1
            max_count = max(max_count, current_count)
        else:
            # print(f"当前连续情况是：{current_count}")
            if current_count != 0:
                max_consecutive.append(current_count)
            if current_count > 3:
                print(f"当前期数是：{index}")
                
            current_count = 0
    return max_count

def safe_index(lst, value):
    """
    返回列表中指定值的索引，如果值不在列表中则返回 -1。

    参数:
    lst (list): 需要搜索的列表。
    value: 需要在列表中查找的值。

    返回:
    int: 值在列表中的索引，或者 -1 如果值不在列表中。
    """
    if value in lst:
        return lst.index(value)+1
    else:
        return -1

# 假设已有的六合彩数据
data = pd.read_csv('/Users/wulinghui/Downloads/' +  sys.argv[1]+'.csv')
data = data.iloc[::-1].reset_index(drop=True)  # 倒排数据

# 定义窗口大小  120(0.52) 150(0.51)  190(512)  210(508)
window_size = 120
# 初始化用于测试的变量
test_results = []  # 存储测试结果的数据
test_results_csv = []
initial_data_size = 150  # 初始数据量
# 使用拉普拉斯平滑
total_data = len(data)
count_total = 0
count_win = 0
cur_expect = 0
# 开始逐次预测
for i in range(initial_data_size, total_data):
    # cur_data = data[:i]
    cur_data = data[max(0, i - window_size):i]
    cur_expect = int (data['expect'].iloc[i]) 
    #  'code' 
    cur_data_next = int (data['code'].iloc[i])
    # 所有数字范围
    all_numbers = range(1, 50)
    number_counts = Counter()

    # 计算每个数字的出现频率
    for index, row in cur_data.iterrows():
        numbers = row[['normalCode1', 'normalCode2', 'normalCode3', 'normalCode4', 'normalCode5', 'normalCode6' , 'code']]
        number_counts.update(numbers)

    # 使用拉普拉斯平滑
    total_draws = len(cur_data)
    alpha = 1  # 拉普拉斯平滑的平滑参数
    
    #smoothed_probabilities = {num: ( number_counts[num] + alpha) / (total_draws + len(all_numbers) * alpha) for num in all_numbers}
    weight_factor = 1.2  # 例如，1.2 表示近期数据的权重增加 20%
    smoothed_probabilities = {num: (number_counts[num] + alpha) / (total_draws + len(all_numbers) * alpha) for num in all_numbers}


    # 根据概率排序，选择概率最大的前 24 个数字
    predicted_top_numbers = sorted(smoothed_probabilities, key=smoothed_probabilities.get, reverse=True)[:24]
    # print("预测的最有可能出现的号码：", predicted_top_numbers)

    # 对号码进行从小到大的排序
    sorted_top_24_codes = sorted(predicted_top_numbers)
    # 安全获得在预测中的下标位置
    safe_index_value  = safe_index(predicted_top_numbers,cur_data_next)
    test_results.append(safe_index_value)
    # 记录测试结果，包括预测的24个号码，实际的特码以及是否预测正确
    test_results_csv.append({
        'expect' : cur_expect,
        'prediction_index': safe_index_value,
        'predicted_codes': predicted_top_numbers,
        'actual_code': cur_data_next
    })

    count_total += 1
    if cur_data_next in predicted_top_numbers:
        count_win += 1
    # print(f"{cur_expect}期预测号码：{sorted_top_24_codes} ;对错情况:{ '对' if cur_data_next in predicted_top_numbers else '错'} ; 开奖号码:{cur_data_next} ;预测在[{safe_index_value}]位置" )



# 使用最近的 window_size 期数据来预测最新的一个结果
final_data = data[-window_size:]
number_counts = Counter()

# 计算每个数字的出现频率
for index, row in final_data.iterrows():
    numbers = row[['normalCode1', 'normalCode2', 'normalCode3', 'normalCode4', 'normalCode5', 'normalCode6', 'code']]
    number_counts.update(numbers)

# 使用拉普拉斯平滑
total_draws = len(final_data)
smoothed_probabilities = {num: (number_counts[num] + alpha) / (total_draws + len(all_numbers) * alpha) for num in all_numbers}

# 根据概率排序，选择概率最大的前 24 个数字
final_predicted_top_numbers = sorted(smoothed_probabilities, key=smoothed_probabilities.get, reverse=True)[:24]
sorted_final_top_24_codes = sorted(final_predicted_top_numbers)


# 输出测试结果
result_df = pd.DataFrame(test_results_csv)
result_df.to_csv('lapulasi_test_results.csv', index=False)

print(f"最大连续小于10的次数是: {max_consecutive_less_than_count(test_results,24)}")

max_consecutive_counts = Counter(max_consecutive)
sorted_max_consecutive_counts = sorted(max_consecutive_counts.items(), key=lambda x: x[0])
print(f"连错的总数内容:{len(max_consecutive)}")
for combo, count in sorted_max_consecutive_counts:
    print(f"连错的情况错误 {combo} 次: 出现 {count} 次")

print(f"新资料在{cur_expect+1}期预测号码：{sorted_final_top_24_codes}")
print(f"最新一期预测的最有可能出现的23个号码，越往前概率越大：{final_predicted_top_numbers}")
print(f"合格率 {count_win}/{count_total} : {count_win / count_total} ")

if sys.argv[1] == 'macaujc2':
    platform = '新澳門六合彩'
else:
    platform = '澳門六合彩'

maseege = f"{platform} {cur_expect+1}期: \n{sorted_final_top_24_codes}\n进群获得更多情报： https://t.me/PredictMacaujcValue \n#澳门六合彩 #六合彩 #博彩 #彩票 #发财 #福彩"
# print(maseege)
# API 地址
url = "http://157.173.196.7:5000/send-tweet"
# 发送的数据
data = {
    "message": maseege
}
# 设置请求头
headers = {
    "Content-Type": "application/json"
}
# 发送 POST 请求
response = requests.post(url, headers=headers, data=json.dumps(data))

# 输出返回结果
print("Status Code:", response.status_code)
print("Response:", response.json())  # 假设返回的是 JSON 格式


result = count_error_3_right_combinations(test_results,24)

# 排序：首先按错误次数升序，再按正确次数升序
sorted_result = sorted(result.items(), key=lambda x: (x[0][0], x[0][1]))

# 输出结果
for combo, count in sorted_result:
    print(f"错误 {combo[0]} 次，正确 {combo[1]} 次: 出现 {count} 次")

# print(f"连续错误几次的情况内容是: { count_error_3_right_combinations(test_results,24) }")  20 + 5 + 7 + 5 + 1  18/20
